import Cookies from "js-cookie";
// cookie保存的天数
import config from "@/config";
const { title, cookieExpires } = config;
import store from "@/store";

export const TOKEN_KEY = "Origin-Token";
export const UserInfo = "Origin-UserInfo";

// 将token存放在本地cookies里
export const setToken = (token) => {
  Cookies.set(TOKEN_KEY, token, { expires: cookieExpires || 1 });
};
// 获取token
export const getToken = () => {
  const token = Cookies.get(TOKEN_KEY);
  if (token) return token;
  else return false;
};
// 将用户信息存放在本地load
export const setUserInfo = (info) => {
  localStorage.setItem(UserInfo, JSON.stringify(info));
};
// 从本地存储中获取用户信息
export const getUserInfo = () => {
  const info = JSON.parse(localStorage.getItem(UserInfo));
  // 返回一个对象，包含用户信息
  return info || {};
};
// 从本地存储中获取同步ID
export const getTaskId = () => {
  const id = localStorage.getItem("taskId");
  // 返回一个对象，包含用户信息
  return id || null;
};
// 将路由信息存放在本地load
export const setMenuList = (list) => {
  localStorage.setItem("MenuList", JSON.stringify(list));
};

// 从本地存储中获取路由信息
export const getMserInfo = () => {
  const list = JSON.parse(localStorage.getItem("MenuList"));
  // 返回一个对象，包含用户信息
  return list || [];
};
/**
 * 移除所有cookie
 */
export const removeAllCookie = () => {
  Cookies.remove(TOKEN_KEY);
};
/**
 * 清空缓存
 */
export const clearCache = () => {
  localStorage.clear();
  removeAllCookie();
};
/**
 * @description 根据当前跳转的路由设置显示在浏览器标签的title
 * @param {Object} routeItem 路由对象
 * @param {Object} vm Vue实例
 */
export const setTitle = (routeItem, vm) => {
  const handledRoute = getRouteTitleHandled(routeItem);
  const pageTitle = showTitle(handledRoute, vm);
  const resTitle = pageTitle ? `${title} - ${pageTitle}` : title;
  window.document.title = resTitle;
};
/**
 * @param {Array} list 通过路由列表得到菜单列表
 * @returns {Array}
 */
export const getMenuByRouter = (list) => {
  let res = [];
  myforEach(list, (item) => {
    if (!item.meta) return;

    const isParentRoute = item.meta.isParent;

    // 处理 isParent 路由
    if (isParentRoute) {
      // 默认使用当前路由信息
      let menuItem = {
        icon: item.meta.icon || "Menu",
        title: item.meta.name,
        url: item.path,
        children: null,
      };

      // 如果有子路由则使用第一个子路由的信息（无论是否隐藏）
      if (item.children?.length > 0) {
        const firstChild = item.children[0];
        menuItem = {
          icon: firstChild.meta?.icon || menuItem.icon,
          title: firstChild.meta?.name || menuItem.title,
          url: firstChild.path,
          children: null,
        };
      }

      res.push(menuItem);
    }
    // 处理正常路由（显示自身）
    else if (!item.meta.hideInMenu) {
      // 获取所有不隐藏的子路由
      const visibleChildren =
        item.children?.filter(
          (child) => child.meta && !child.meta.hideInMenu
        ) || [];

      // 如果没有可见子项，但存在子路由（即使都是隐藏的）
      if (visibleChildren.length === 0 && item.children?.length > 0) {
        // 显示第一个子路由（即使它是隐藏的）
        const firstChild = item.children[0];
        res.push({
          icon: firstChild.meta?.icon || "Menu",
          title: firstChild.meta?.name,
          url: firstChild.path,
          children: null,
        });
      }
      // 只有一个可见子项
      else if (visibleChildren.length === 1) {
        const child = visibleChildren[0];
        res.push({
          icon: child.meta?.icon || "Menu",
          title: child.meta?.name,
          url: child.path,
          children: null,
        });
      }
      // 多个可见子项
      else if (visibleChildren.length > 1) {
        const menuItem = {
          icon: item.meta.icon || "Menu",
          title: item.meta.name,
          url: item.path,
          children: getMenuByRouter(visibleChildren),
        };
        res.push(menuItem);
      }
      // 没有子路由
      else {
        res.push({
          icon: item.meta.icon || "Menu",
          title: item.meta.name,
          url: item.path,
          children: null,
        });
      }
    }
  });
  return res;
};
export const myforEach = (arr, fn) => {
  if (!arr.length || !fn) return;
  let i = -1;
  let len = arr.length;
  while (++i < len) {
    let item = arr[i];
    fn(item, i, arr);
  }
};
// 由于后端没处理数据，需要前端自己处理(顺便做权限处理)
export const handleMenuByRouter = (list) => {
  console.log("数据", list);

  let reslut = [];
  // 先按照循序把 没有父级菜单的就添加进来
  list.forEach((item) => {
    if (!item.menuParentId) {
      reslut.push({
        url: item.menuUrl,
        title: item.menuName,
        icon: item.menuIconUrl || "Menu",
        showType: item.showType, //页面展示方式（0：页面1：内嵌，2：外链）
        isUserSee: item.isUserSee, //用户可见不可见
        id: item.menuId,
        children: null,
      });
    }
  });
  // 然后再把有父级的菜单一一加到父级菜单的children里面
  list.forEach((item) => {
    // 找到父级菜单的
    if (item.menuParentId) {
      // 如果有父级id 的就添加进父级菜单的children
      reslut.forEach((menu) => {
        if (menu.id === item.menuParentId) {
          if (!menu.children) {
            menu.children = [];
          }
          menu.children.push({
            url: item.menuUrl,
            title: item.menuName,
            icon: item.menuIconUrl || "Menu",
            showType: item.showType, //页面展示方式（0：页面1：内嵌，2：外链）
            isUserSee: item.isUserSee, //用户可见不可见
            id: item.menuId,
            children: null,
          });
        }
      });
    }
  });
  console.log("整理好的全部的路由", reslut);

  // 这里是整理好的全部的路由
  // return reslut || []
  const { UserInfo = {} } = store.getters;
  // 需要判断用户可见不可见
  let userRole = UserInfo.userRole; //当前用户的角色
  if (userRole == "admin") {
    return reslut || [];
  } else {
    return getUserbarRoutes(reslut);
  }
};
export const getUserbarRoutes = (list) => {
  return list.filter((item) => {
    // 过滤出 isUserSee == 1 的项
    const isValid = item.isUserSee == 1;

    // 如果有子级，递归处理
    if (item.children && item.children.length > 0) {
      const validChildren = getUserbarRoutes(item.children);

      // 如果子级有符合条件的，保留当前项
      if (validChildren.length > 0) {
        // 创建新对象，避免修改原数据
        return {
          ...item,
          children: validChildren,
        };
      }
    }

    return isValid;
  });
};
